﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IPC.ListConnect
{
    public static class ToolUtil
    {
        /// <summary>
        /// 转为bool类型  第一个返回值为转换后的值，第二个为是否成功
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static (bool,bool) ToBool(this string str)
        {
            if(str.Replace(" ","") == "1" || str.Replace(" ","").ToLower() == "true")
            {
                return (true,true);
            }
            else if(str.Replace(" ", "") == "0" || str.Replace(" ", "").ToLower() == "false")
            {
                return(false,true);
            }

            return (false,false);
        }

        /// <summary>
        /// 转为byte类型  第一个返回值为转换后的值，第二个为是否成功
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static (byte, bool) ToByte(this string str)
        {
            if(byte.TryParse(str, out byte val))
            {
                return (val, true);
            }
            return (0, false);
        }

        /// <summary>
        /// 转为ushort类型  第一个返回值为转换后的值，第二个为是否成功
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static (ushort, bool) ToUShort(this string str)
        {
            if (ushort.TryParse(str, out var b))
            {
                return (b, true);
            }
            return (0, false);
        }

        /// <summary>
        /// 转为short类型  第一个返回值为转换后的值，第二个为是否成功
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static (short, bool) ToShort(this string str)
        {
            if (short.TryParse(str, out var b))
            {
                return (b, true);
            }
            return (0, false);
        }

        /// <summary>
        /// 转为uint类型  第一个返回值为转换后的值，第二个为是否成功
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static (uint, bool) ToUInt(this string str)
        {
            if (uint.TryParse(str, out var b))
            {
                return (b, true);
            }
            return (0, false);
        }

        /// <summary>
        /// 转为int类型  第一个返回值为转换后的值，第二个为是否成功
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static (int, bool) ToInt(this string str)
        {
            if (int.TryParse(str, out int b))
            {
                return (b, true);
            }
            return (0, false);
        }


        /// <summary>
        /// 转为ulong类型  第一个返回值为转换后的值，第二个为是否成功
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static (ulong, bool) ToUInt64(this string str)
        {
            if (ulong.TryParse(str, out var b))
            {
                return (b, true);
            }
            return (0, false);
        }

        /// <summary>
        /// 转为long类型  第一个返回值为转换后的值，第二个为是否成功
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static (long, bool) ToInt64(this string str)
        {
            if (long.TryParse(str, out long b))
            {
                return (b, true);
            }
            return (0, false);
        }

        /// <summary>
        /// 转为float类型  第一个返回值为转换后的值，第二个为是否成功
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static (float, bool) ToFloat(this string str)
        {
            if (float.TryParse(str, out var b))
            {
                return (b, true);
            }
            return (0, false);
        }

        /// <summary>
        /// 转为double类型  第一个返回值为转换后的值，第二个为是否成功
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static (double, bool) ToDouble(this string str)
        {
            if (double.TryParse(str, out var b))
            {
                return (b, true);
            }
            return (0, false);
        }

        /// <summary>
        /// 转int类型
        /// </summary>
        /// <param name="s"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static int ToInt(this string s, int defaultValue)
        {
            bool b = int.TryParse(s, out int i);
            if (b)
            {
                return i;
            }
            return defaultValue;
        }

        /// <summary>
        /// 转double类型
        /// </summary>
        /// <param name="s"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static double ToDouble(this string s, double defaultValue)
        {
            bool b = double.TryParse(s, out double i);
            if (b)
            {
                return i;
            }
            return defaultValue;
        }

        /// <summary>
        /// 转byte类型
        /// </summary>
        /// <param name="s"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static byte ToByte(this string s, byte defaultValue)
        {
            bool b = byte.TryParse(s, out byte i);
            if (b)
            {
                return i;
            }
            return defaultValue;
        }

        public static bool ToBool(this string s,bool defaultValue)
        {
            if(s.ToLower() == "true" || s == "1")
            {
                return true;
            }
            else if(s.ToLower() == "false" || s == "0")
            {
                return false;
            }
            return defaultValue;
        }
    }
}
